Otherware/Otherware_1_SB_Development.iso/mac/developm/source/cdevskel.cpt/CdevSkeleton2.0 ƒ/DialogUtils.p

Text File | 1991-08-21 | 15.8 KB | 719 lines

{    DialogUtils.p}
{    Copyright ⌐ 1991, Michael J. Conrad}
{}
{    Handles a bunch of dialog stuff.}

UNIT DialogUtils;

INTERFACE

    USES
        CList;

    TYPE
        dialogItemRec = RECORD
                hasText: Boolean;
                hasList: Boolean;
            END;

    CONST
        textMargin = 2;

    VAR
        dialogTE: TEHandle;            { Handle for the scrolling text (if any) }
        dialogTERect: Rect;            { Rect for the scrolling text }
        dialogList: CList;                { The dialog's list (if any) }
        dialogItems: dialogItemRec;
        dialogScrollBar: ControlHandle;
        dialogDoubleClick: Boolean;

        screenBounds: Rect;

{Dialog utilities}
    FUNCTION GetDCValue (d: DialogPtr;
                                    item: integer): integer;
    PROCEDURE SetDCtl (d: DialogPtr;
                                    item: integer;
                                    value: integer);
    PROCEDURE HiliteDItem (d: DialogPtr;
                                    item: integer;
                                    value: integer);
    PROCEDURE SetDlgText (d: DialogPtr;
                                    item: integer;
                                    theText: Str255);
    FUNCTION GetDlgText (d: DialogPtr;
                                    item: integer): Str255;
    PROCEDURE ToggleCtl (d: DialogPtr;
                                    item: integer);
    PROCEDURE CenterDialog (d: DialogPtr;
                                    id: integer;
                                    horz, vert: Boolean);
    FUNCTION CenterNewDialog (id: integer;
                                    dStorage: Ptr;
                                    inFrontOf: WindowPtr;
                                    font, size: integer): DialogPtr;
    FUNCTION DlgFilter (d: DialogPtr;
                                    VAR e: EventRecord;
                                    VAR itemHit: integer): Boolean;
    FUNCTION TestDlgCtl (d: DialogPtr;
                                    i: integer): Boolean;
    PROCEDURE SetUpUserItem (d: DialogPtr;
                                    i: integer;
                                    userProc: ProcPtr);
    PROCEDURE FrameDItem (d: DialogPtr;
                                    i: integer);
    FUNCTION GetDlgRect (id: integer): Rect;
    FUNCTION GetItemRect (d: DialogPtr;
                                    item: integer): Rect;
    FUNCTION GetCtrlHndl (d: DialogPtr;
                                    item: integer): ControlHandle;
    PROCEDURE DlgUpdate (d: DialogPtr);
    PROCEDURE FlashDItem (dp: DialogPtr;
                                    item: integer);

{Special scrolling text dialog}
    PROCEDURE InitScrollingDialog (d: DialogPtr;
                                    uItem: integer;
                                    textID: integer);
    PROCEDURE DisposeScrollingDialog (d: DialogPtr);
    PROCEDURE SetDialogText (textID: integer);

{Special list dialog}
    PROCEDURE InitDialogList (dList: CList);

{Alert Utilities}
    FUNCTION CenterAlert (id: integer;
                                    filterProc: ProcPtr): integer;

    PROCEDURE InitDialogUtils;

IMPLEMENTATION

    PROCEDURE DlgNullEvt (d: DialogPtr;
                                    e: EventRecord);
    forward;

{--------------------------------Ñ--------------------------------}

    PROCEDURE InitDialogUtils;
        VAR
            p1, p2: GrafPtr;

    BEGIN
        GetPort(p1);

        p2 := GrafPtr(NewPtr(sizeof(GrafPort)));
        OpenPort(p2);
        screenBounds := p2^.portBits.bounds;

        ClosePort(p2);
        DisposPtr(Pointer(p2));

        SetPort(p1);
    END;

{--------------------------------Ñ--------------------------------}

    FUNCTION GetMBarHeight: integer;
    INLINE
        $3EB8, $0BAA;

{ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ    }
{ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ Dialog List Routines ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ    }
{ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ    }

{ The List object must be passed to this routine! }
    PROCEDURE InitDialogList (dList: CList);
    BEGIN
        IF dList <> NIL THEN
            dialogList := dList;
        dialogItems.hasList := True;
    END;

{ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ    }
{ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ Scrolling Dialog Routines ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ    }
{ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ    }

    PROCEDURE AdjustText (theScrollBar: ControlHandle);
        VAR
            oldScroll: integer;
            newScroll: integer;

    BEGIN
        HLock(Handle(dialogTE));

        WITH dialogTE^^ DO
            BEGIN
                oldScroll := viewRect.top - destRect.top;
                newScroll := GetCtlValue(theScrollBar) * lineHeight;

                TEScroll(0, oldScroll - newScroll, dialogTE);
            END;
        HUnLock(Handle(dialogTE));
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE ScrlText (theScrollBar: ControlHandle;
                                    thePart: integer);
        VAR
            delta: integer;
            oldValue: integer;
            moveMent: integer;

    BEGIN
        CASE thePart OF
            inUpButton:
                delta := -1;
            inDownButton:
                delta := +1;
            inPageUp:
                WITH dialogTE^^, viewRect DO
                    delta := (top - bottom) DIV lineHeight + 1;
            inPageDown:
                WITH dialogTE^^, viewRect DO
                    delta := (bottom - top) DIV lineHeight - 1;
            OTHERWISE
                ;
        END;

        IF (thePart <> 0) THEN
            BEGIN
                oldValue := GetCtlValue(theScrollBar);
                moveMent := oldValue + delta;
                IF moveMent > GetCtlMax(theScrollBar) THEN
                    moveMent := GetCtlMax(theScrollBar);
                IF moveMent < GetCtlMin(theScrollBar) THEN
                    moveMent := GetCtlMin(theScrollBar);

                SetCtlValue(theScrollBar, moveMent);

                AdjustText(theScrollBar);
            END;
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE SetScrollBar (theScrollBar: ControlHandle);
        VAR
            windowHeight, maxTop: integer;

    BEGIN
        WITH dialogTE^^, viewRect DO
            BEGIN
                windowHeight := (bottom - top) DIV lineHeight;
                maxTop := nLines - windowHeight;
            END;

        IF (maxTop <= 0) THEN
            BEGIN
                maxTop := 0;
                HiliteControl(theScrollBar, 255);
            END
        ELSE
            HiliteControl(theScrollBar, 0);

        SetCtlMin(theScrollBar, 0);
        SetCtlMax(theScrollBar, maxTop);
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE SetDialogText (textID: integer);
        VAR
            h: Handle;

    BEGIN
        IF dialogItems.hasText THEN
            BEGIN
                IF dialogTE <> NIL THEN
                    BEGIN
                        h := Get1Resource('TEXT', textID);
                        IF h <> NIL THEN
                            BEGIN
                                TESetText(h^, GetHandleSize(h), dialogTE);
                                TECalText(dialogTE);
                                EraseRect(dialogTE^^.viewRect);
                                InvalRect(dialogTE^^.viewRect);
                                SetCtlValue(dialogScrollBar, 0);
                                SetScrollBar(dialogScrollBar);
                                AdjustText(dialogScrollBar);
                            END;
                    END;
            END;
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE InitScrollingDialog (d: DialogPtr;
                                    uItem: integer;
                                    textID: integer);
        VAR
            textRect: Rect;
            scrollItem: integer;

    BEGIN
        scrollItem := uItem + 1;
        dialogTERect := GetItemRect(d, uItem);
        textRect := dialogTERect;

        dialogItems.hasText := True;

        InsetRect(textRect, textMargin, textMargin);
        dialogTE := TENew(textRect, textRect);
        dialogScrollBar := GetCtrlHndl(d, scrollItem);
        SetDialogText(textID);
        TEActivate(dialogTE);
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE DisposeScrollingDialog (d: DialogPtr);
    BEGIN
        TEDispose(dialogTE);
        dialogItems.hasText := False;
        DisposDialog(d);
    END;


{ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ    }
{ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ Standard Dialog Routines ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ    }
{ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ    }

    FUNCTION GetCtrlHndl (d: DialogPtr;
                                    item: integer): ControlHandle;
        VAR
            itype: integer;
            irect: Rect;
            ihan: Handle;

    BEGIN
        GetDItem(d, item, itype, ihan, irect);
        GetCtrlHndl := ControlHandle(ihan);
    END;

{--------------------------------Ñ--------------------------------}

    FUNCTION GetItemRect (d: DialogPtr;
                                    item: integer): Rect;
        VAR
            itype: integer;
            irect: Rect;
            ihan: Handle;

    BEGIN
        GetDItem(d, item, itype, ihan, irect);
        GetItemRect := irect;
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE ToggleCtl (d: DialogPtr;
                                    item: integer);
    BEGIN
        SetDCtl(d, item, ORD(GetDCValue(d, item) = 0));
    END;

{--------------------------------Ñ--------------------------------}

    FUNCTION GetDlgText (d: DialogPtr;
                                    item: integer): Str255;
        VAR
            itype: integer;
            ihan: handle;
            irect: Rect;

    BEGIN
        GetDlgText := '';
        GetDItem(d, item, itype, ihan, irect);
        IF (itype = editText) OR (itype = editText + itemDisable) THEN
            GetIText(ihan, GetDlgText);
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE SetDlgText (d: DialogPtr;
                                    item: integer;
                                    theText: Str255);
        VAR
            itype: integer;
            ihan: handle;
            irect: Rect;

    BEGIN
        GetDItem(d, item, itype, ihan, irect);
        IF (itype = editText) OR (itype = editText + itemDisable) OR (itype = statText) OR (itype = statText + itemDisable) THEN
            SetIText(ihan, theText);
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE HiliteDItem (d: DialogPtr;
                                    item: integer;
                                    value: integer);
        VAR
            itype: integer;
            ihan: handle;
            irect: Rect;

    BEGIN
        GetDItem(d, item, itype, ihan, irect);
        IF (itype = ctrlItem + chkCtrl) OR (itype = ctrlItem + radCtrl) OR (itype = ctrlItem + btnCtrl) THEN
            HiliteControl(ControlHandle(ihan), value);
    END;

{--------------------------------Ñ--------------------------------}

    FUNCTION GetDCValue (d: DialogPtr;
                                    item: integer): integer;
        VAR
            itype: integer;
            ihan: handle;
            irect: Rect;

    BEGIN
        GetDCValue := 0;
        GetDItem(d, item, itype, ihan, irect);
        IF (itype = ctrlItem + chkCtrl) OR (itype = ctrlItem + radCtrl) THEN
            GetDCValue := GetCtlValue(ControlHandle(ihan));
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE SetDCtl (d: DialogPtr;
                                    item: integer;
                                    value: integer);
        VAR
            itype: integer;
            ihan: handle;
            irect: Rect;

    BEGIN
        GetDItem(d, item, itype, ihan, irect);
        IF (itype = ctrlItem + chkCtrl) OR (itype = ctrlItem + radCtrl) THEN
            SetCtlValue(ControlHandle(ihan), value);
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE PositionDialog (theType: ResType;
                                    theID: integer);
        VAR
            r: Rect;
            aRectPtr: RectPtr;
            dlgTemplate: Handle;
            left, top: integer;

    BEGIN
        dlgTemplate := GetResource(theType, theID);
        aRectPtr := RectPtr(dlgTemplate^);
        r := aRectPtr^;

        left := (screenBounds.right - (r.right - r.left)) DIV 2;
        top := (screenBounds.bottom - (r.bottom - r.top)) DIV 3;

        IF top < GetMBarHeight + 7 THEN
            top := GetMBarHeight + 7;

        r.right := r.right + left - r.left;
        r.left := left;
        r.bottom := r.bottom + top - r.top;
        r.top := top;

        aRectPtr^ := r;
    END;

{--------------------------------Ñ--------------------------------}

    FUNCTION CenterNewDialog (id: integer;
                                    dStorage: Ptr;
                                    inFrontOf: WindowPtr;
                                    font, size: integer): DialogPtr;
        VAR
            newDlg: DialogPtr;

    BEGIN
        PositionDialog('DLOG', id);
        newDlg := GetNewDialog(id, dStorage, inFrontOf);
        SetPort(newDlg);

        TextFont(font);
        TextSize(size);

        ShowWindow(newDlg);

        dialogItems.hasText := False;
        dialogItems.hasList := False;

        CenterNewDialog := newDlg;
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE DlgNullEvt (d: DialogPtr;
                                    e: EventRecord);
        VAR
            savePort: GrafPtr;
            mLoc: Point;
            i, itype: integer;
            ihan: Handle;
            irect: Rect;
            iCurs: CursHandle;

    BEGIN
        GetPort(savePort);
        SetPort(d);
        mLoc := e.where;
        GlobalToLocal(mLoc);

        i := FindDItem(d, mLoc) + 1;

        IF (i >= 1) THEN
            BEGIN
                GetDItem(d, i, itype, ihan, irect);
                IF (itype = editText) THEN
                    BEGIN
                        iCurs := GetCursor(iBeamCursor);
                        SetCursor(iCurs^^);
                    END
                ELSE
                    InitCursor;
            END
        ELSE
            InitCursor;

        SetPort(savePort);
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE DlgUpdate (d: DialogPtr);
        VAR
            savePort: GrafPtr;
            irect, r: Rect;

    BEGIN
        GetPort(savePort);
        SetPort(d);

        BeginUpdate(d);

        irect := GetItemRect(d, DialogPeek(d)^.aDefItem);
        PenSize(3, 3);
        InsetRect(irect, -4, -4);
        FrameRoundRect(irect, 16, 16);
        PenSize(1, 1);

        IF dialogItems.hasText THEN
            BEGIN
                r := dialogTERect;
                InsetRect(r, textMargin, textMargin);
                TEUpdate(r, dialogTE);
                FrameRect(dialogTERect);
            END;

        IF dialogItems.hasList THEN
            dialogList.ListUpdate;

        DrawDialog(d);
        EndUpdate(d);

        SetPort(savePort);
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE FlashDItem (dp: DialogPtr;
                                    item: integer);
        VAR
            tickScratch: longint;
            itype: integer;
            ihan: Handle;
            irect: Rect;

    BEGIN
        GetDItem(dp, item, itype, ihan, irect);
        HiliteControl(ControlHandle(ihan), 1);
        Delay(10, tickScratch);
        HiliteControl(ControlHandle(ihan), 0);
    END;

{--------------------------------Ñ--------------------------------}

    FUNCTION DlgFilter (d: DialogPtr;
                                    VAR e: EventRecord;
                                    VAR itemHit: integer): Boolean;
        VAR
            chCode: integer;
            thePart, temp: integer;
            pt: Point;
            theControl: ControlHandle;

    BEGIN
        SetUpA4;

        DlgFilter := False;

        CASE e.what OF
            nullEvent:
                DlgNullEvt(d, e);

            activateEvt:
                BEGIN
                END;

            updateEvt:
                BEGIN
                    IF (DialogPtr(e.message) = d) THEN
                        DlgUpdate(d);
                END;

            mouseDown:
                BEGIN
                    pt := e.where;
                    GlobalToLocal(pt);
                    IF dialogItems.hasText THEN
                        BEGIN
                            pt := e.where;
                            GlobalToLocal(pt);
                            thePart := FindControl(pt, d, theControl);
                            IF theControl = dialogScrollBar THEN
                                IF (thePart = inThumb) THEN
                                    BEGIN
                                        temp := TrackControl(theControl, pt, NIL);
                                        AdjustText(theControl);
                                        DlgFilter := True;
                                    END
                                ELSE IF (thePart >= inUpButton) THEN
                                    BEGIN
                                        temp := TrackControl(theControl, pt, @scrlText);
                                        DlgFilter := True;
                                    END;
                        END;
                    IF dialogItems.hasList THEN
                        BEGIN
                            IF PtInRect(pt, dialogList.listRect) THEN
                                BEGIN
                                    GlobalToLocal(e.where);
                                    dialogDoubleClick := dialogList.DoList(e);
                                    DlgFilter := True;
                                    LocalToGlobal(e.where);
                                END;
                        END;
                END;

            keyDown:
                BEGIN
                    chCode := BitAnd(e.message, charCodeMask);
                    IF (chCode = 13) OR (chCode = 3) AND (TestDlgCtl(d, 1)) THEN
                        BEGIN
                            itemHit := 1;
                            FlashDItem(d, itemHit);
                            DlgFilter := True;
                        END
                    ELSE IF (chCode = 27) AND (TestDlgCtl(d, 2)) THEN
                        BEGIN
                            itemHit := 2;
                            FlashDItem(d, itemHit);
                            DlgFilter := True;
                        END;
                END;

            OTHERWISE
                ;
        END;

        RestoreA4;
    END;

{--------------------------------Ñ--------------------------------}

    FUNCTION CenterAlert (id: integer;
                                    filterProc: ProcPtr): integer;
        VAR
            theAlert: AlertTHndl;
            width, height: integer;

    BEGIN
        PositionDialog('ALRT', id);
        CenterAlert := Alert(id, filterProc);

        FreeAlert(id);
    END;

{--------------------------------Ñ--------------------------------}

    FUNCTION TestDlgCtl (d: DialogPtr;
                                    i: integer): Boolean;
        VAR
            itype: integer;
            ihan: Handle;
            irect: Rect;

    BEGIN
        GetDItem(d, i, itype, ihan, irect);
        IF (itype = ctrlItem + btnCtrl) OR (itype = ctrlItem + chkCtrl) OR (itype = ctrlItem + radCtrl) THEN
            TestDlgCtl := ControlHandle(ihan)^^.contrlHilite <> $FF;
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE SetUpUserItem (d: DialogPtr;
                                    i: integer;
                                    userProc: ProcPtr);
        VAR
            itype: integer;
            ihan: Handle;
            irect: Rect;

    BEGIN
        GetDItem(d, i, itype, ihan, irect);
        SetDItem(d, i, itype, Handle(userProc), irect);
    END;

{--------------------------------Ñ--------------------------------}

    PROCEDURE FrameDItem (d: DialogPtr;
                                    i: integer);
        VAR
            savePort: GrafPtr;
            itype: integer;
            ihan: Handle;
            irect: Rect;
            gray: Pattern;

    BEGIN
        GetPort(savePort);
        SetPort(d);

        GetDItem(d, i, itype, ihan, irect);
        WITH irect DO
            IF (bottom - top <= 1) OR (right - left <= 1) THEN
                BEGIN
                    GetIndPattern(gray, SysPatListId, 5);
                    PenPat(gray);
                END;

        FrameRect(irect);
        PenNormal;

        SetPort(savePort);
    END;

{--------------------------------Ñ--------------------------------}

    FUNCTION GetDlgRect (id: integer): Rect;
        VAR
            dTh: DialogTHndl;

    BEGIN
        dTH := DialogTHndl(GetResource('DLOG', id));
        IF (dTH = NIL) THEN
            Exit(GetDlgRect);

        GetDlgRect := dTH^^.boundsRect;
    END;

{--------------------------------Ñ--------------------------------}

END.